#include "Serial_RX.h"
#define Sx2 cross_x-1.0
#define Sx1 Sx2-9.0
#define Sx3 Sx2+9.0
/*角度传感器变量定义*/
struct SAcc 		stcAcc;
struct SGyro 		stcGyro;
struct SAngle 	stcAngle;

//每个串口需要设置一次，接收不定长的数据，只接收~与0D0A之间的数据
/**************************************************************************
函数功能：串口1接收函数，帧头-‘~’，帧尾-“\r\n”
入口参数：串口1接收的单字节数据
返回  值：无
**************************************************************************/
void UART1_Receive(uint8_t RXBUF)
{
    uint16_t UART1_Max_Recv_Len = 40;                           //最大接收长度
    static uint16_t UART1_STA = 0;                          //数据长度计数，同时用最后一位表示接收0A,倒数第二位表示接收0D
    static uint8_t UART1_RX_BUF[20],Uart_FLag= 0;
		RXBUF == '~' ? Uart_FLag = 1 :0;
    if((UART1_STA&0x8000)==0 && Uart_FLag)                      //未接收到0D0A
    {
        if(UART1_STA&0x4000)                                    //上一位接收到0x0d
        {
            if(RXBUF!=0x0a)UART1_STA=0;                         //接收到0D后下一位不是0A,重新开始
            else UART1_STA|=0x8000;                             //接收到0X0A
        }
        else                                                    //还没收到0X0D
        {
            if(RXBUF==0x0d)UART1_STA|=0x4000;                   //接收到0X0D
            else
            {
                if(RXBUF!=0x0A && RXBUF!=' ')
                {
                    UART1_RX_BUF[UART1_STA&0X3FFF]=RXBUF;         //存储数据
                    UART1_STA++;
                }                                 //接收数据计数
                if(UART1_STA>(UART1_Max_Recv_Len-1))UART1_STA=0;//接收数据长度错误,重新开始接收
            }
        }
    }                                                           //接收到0D0A，处理通信数据
    if(UART1_STA&0x8000 && UART1_STA&0x4000 && Uart_FLag)
    {
        //处理函数//
        UART1Data_Process(UART1_RX_BUF,UART1_STA&0X3FFF);
        UART1_STA = 0;   
				Uart_FLag = 0; 
    }
}

/**************************************************************************
函数功能：串口2接收函数，帧头-‘~’，帧尾-“\r\n”
入口参数：串口2接收的单字节数据
返回  值：无
**************************************************************************/
void UART2_Receive(uint8_t RXBUF)
{
	uint16_t UART2_Max_Recv_Len = 20;                           //最大接收长度
	static uint16_t UART2_STA = 0;                              //数据长度计数，同时用最后一位表示接收0A,倒数第二位表示接收0D
	static uint8_t UART2_RX_BUF[20],Uart_FLag = 0;
	RXBUF == '~' ? Uart_FLag = 1 : 0;
	if((UART2_STA&0x8000)==0 && Uart_FLag)                      //未接收到0D0A[只有0D不能使用，0A和~在第一个~和0D之间可以使用]
	{
			if(UART2_STA&0x4000)                                    //上一位接收到0x0d
			{
					if(RXBUF!=0x0a)UART2_STA=0;                         //接收到0D后下一位不是0A,重新开始
					else UART2_STA|=0x8000;                             //接收到0X0A
			}
			else                                                    //还没收到0X0D
			{
					if(RXBUF==0x0d)UART2_STA|=0x4000;                   //接收到0X0D
					else
					{
							if(RXBUF!=0x0A && RXBUF!=' ')
							{
									UART2_RX_BUF[UART2_STA&0X3FFF]=RXBUF;         //存储数据
									UART2_STA++;
							}                                 //接收数据计数
							if(UART2_STA>(UART2_Max_Recv_Len-1))UART2_STA=0;//接收数据长度错误,重新开始接收
					}
			}
	}                                                           //接收到0D0A，处理通信数据
	if(UART2_STA&0x8000 && UART2_STA&0x4000 && Uart_FLag)
	{
		//处理函数//
		UART2Data_Process(UART2_RX_BUF,UART2_STA&0X3FFF);
		UART2_STA = 0;                                          //处理完成，计数清零
		Uart_FLag = 0;
	}
}

/**************************************************************************
函数功能：串口3接收函数，帧头-‘~’，帧尾-“\r\n”
入口参数：串口3接收的单字节数据
返回  值：无
**************************************************************************/
void UART3_Receive(uint8_t RXBUF)
{
	uint16_t UART3_Max_Recv_Len = 20;                           //最大接收长度
	static uint16_t UART3_STA = 0;                              //数据长度计数，同时用最后一位表示接收0A,倒数第二位表示接收0D
	static uint8_t UART3_RX_BUF[20],Uart_FLag = 0;
	RXBUF == '~' ? Uart_FLag = 1 : 0;
	if((UART3_STA&0x8000)==0 && Uart_FLag)                      //未接收到0D0A[只有0D不能使用，0A和~在第一个~和0D之间可以使用]
	{
			if(UART3_STA&0x4000)                                    //上一位接收到0x0d
			{
					if(RXBUF!=0x0a)UART3_STA=0;                         //接收到0D后下一位不是0A,重新开始
					else UART3_STA|=0x8000;                             //接收到0X0A
			}
			else                                                    //还没收到0X0D
			{
					if(RXBUF==0x0d)UART3_STA|=0x4000;                   //接收到0X0D
					else
					{
							if(RXBUF!=0x0A && RXBUF!=' ')
							{
									UART3_RX_BUF[UART3_STA&0X3FFF]=RXBUF;         //存储数据
									UART3_STA++;
							}                                 //接收数据计数
							if(UART3_STA>(UART3_Max_Recv_Len-1))UART3_STA=0;//接收数据长度错误,重新开始接收
					}
			}
	}                                                           //接收到0D0A，处理通信数据
	if(UART3_STA&0x8000 && UART3_STA&0x4000 && Uart_FLag)
	{
		//处理函数//
		UART3Data_Process(UART3_RX_BUF,UART3_STA&0X3FFF);
		UART3_STA = 0;                                          //处理完成，计数清零
		Uart_FLag = 0;
	}
}
/**************************************************************************
函数功能：串口5接收函数，帧头-‘~’，帧尾-“\r\n”
入口参数：串口5接收的单字节数据
返回  值：无
**************************************************************************/
void UART4_Receive(uint8_t RXBUF)
{
	uint16_t UART4_Max_Recv_Len = 20;                           //最大接收长度
	static uint16_t UART4_STA = 0;                              //数据长度计数，同时用最后一位表示接收0A,倒数第二位表示接收0D
	static uint8_t UART4_RX_BUF[20],Uart_FLag = 0;
	RXBUF == '~' ? Uart_FLag = 1 : 0;
	if((UART4_STA&0x8000)==0 && Uart_FLag)                      //未接收到0D0A[只有0D不能使用，0A和~在第一个~和0D之间可以使用]
	{
			if(UART4_STA&0x4000)                                    //上一位接收到0x0d
			{
					if(RXBUF!=0x0a)UART4_STA=0;                         //接收到0D后下一位不是0A,重新开始
					else UART4_STA|=0x8000;                             //接收到0X0A
			}
			else                                                    //还没收到0X0D
			{
					if(RXBUF==0x0d)UART4_STA|=0x4000;                   //接收到0X0D
					else
					{
							if(RXBUF!=0x0A && RXBUF!=' ')
							{
									UART4_RX_BUF[UART4_STA&0X3FFF]=RXBUF;         //存储数据
									UART4_STA++;
							}                                 //接收数据计数
							if(UART4_STA>(UART4_Max_Recv_Len-1))UART4_STA=0;//接收数据长度错误,重新开始接收
					}
			}
	}                                                           //接收到0D0A，处理通信数据
	if(UART4_STA&0x8000 && UART4_STA&0x4000 && Uart_FLag)
	{
		//处理函数//
		UART4Data_Process(UART4_RX_BUF,UART4_STA&0X3FFF);
		UART4_STA = 0;                                          //处理完成，计数清零
		Uart_FLag = 0;
	}
}
/**************************************************************************
函数功能：串口5接收函数，帧头-‘~’，帧尾-“\r\n”
入口参数：串口5接收的单字节数据
返回  值：无
**************************************************************************/
void UART5_Receive(uint8_t RXBUF)
{
	uint16_t UART5_Max_Recv_Len = 20;                           //最大接收长度
	static uint16_t UART5_STA = 0;                              //数据长度计数，同时用最后一位表示接收0A,倒数第二位表示接收0D
	static uint8_t UART5_RX_BUF[20],Uart_FLag = 0;
	RXBUF == '~' ? Uart_FLag = 1 : 0;
	if((UART5_STA&0x8000)==0 && Uart_FLag)                      //未接收到0D0A[只有0D不能使用，0A和~在第一个~和0D之间可以使用]
	{
			if(UART5_STA&0x4000)                                    //上一位接收到0x0d
			{
					if(RXBUF!=0x0a)UART5_STA=0;                         //接收到0D后下一位不是0A,重新开始
					else UART5_STA|=0x8000;                             //接收到0X0A
			}
			else                                                    //还没收到0X0D
			{
					if(RXBUF==0x0d)UART5_STA|=0x4000;                   //接收到0X0D
					else
					{
							if(RXBUF!=0x0A && RXBUF!=' ')
							{
									UART5_RX_BUF[UART5_STA&0X3FFF]=RXBUF;         //存储数据
									UART5_STA++;
							}                                 //接收数据计数
							if(UART5_STA>(UART5_Max_Recv_Len-1))UART5_STA=0;//接收数据长度错误,重新开始接收
					}
			}
	}                                                           //接收到0D0A，处理通信数据
	if(UART5_STA&0x8000 && UART5_STA&0x4000 && Uart_FLag)
	{
		//处理函数//
		UART5Data_Process(UART5_RX_BUF,UART5_STA&0X3FFF);
		UART5_STA = 0;                                          //处理完成，计数清零
		Uart_FLag = 0;
	}
}

/**************************************************************************
函数功能：串口接收数据处理函数，通过特定协议修改3轴速度
入口参数：串口接收的一段数据与其长度
返回  值：无
**************************************************************************/
int UART1Data_Process(uint8_t *UART_RX_BUF,uint16_t UART_STA)
{
		char i = 0;
		for(i=0;i<UART_STA;i++)
		{
			switch(UART_RX_BUF[i])
			{
					case 'u':		//水果个数
						Fruit_num = CharToNum(&UART_RX_BUF[i+1],UART_STA-i-1);
						break;
					case 'c':		//十字个数
						Cross_num = CharToNum(&UART_RX_BUF[i+1],UART_STA-i-1);
						break;
					case 'r':		//方框个数
						Rec_num = CharToNum(&UART_RX_BUF[i+1],UART_STA-i-1);
						break;
					case 'l':		//总个数
						Target_Len = CharToNum(&UART_RX_BUF[i+1],UART_STA-i-1);
						if(Target_Len==0) Fruit_num = Cross_num = Rec_num =0,ripe=-1;
						break;	
					case 'O':
						DataS_Process(UART_RX_BUF,UART_STA);
						break;
					default:
						break;
			}		
		}
    return 0;
}

int UART2Data_Process(uint8_t *UART_RX_BUF,uint16_t UART_STA)
{
		char i = 0;
		for(i=0;i<UART_STA;i++)
		{
			switch(UART_RX_BUF[i])
			{
					case 'S':
						armstate = CharToNum(&UART_RX_BUF[i+1],UART_STA-i-1);
					break;
					default:break;
			}		
		}
    return 0;
}

int UART3Data_Process(uint8_t *UART_RX_BUF,uint16_t UART_STA)
{
		char i = 0;
		for(i=0;i<UART_STA;i++)
		{
			switch(UART_RX_BUF[i])
			{
					case 'S':
						carstate = CharToNum(&UART_RX_BUF[i+1],UART_STA-i-1);
					break;
					default:break;
			}		
		}
    return 0;
}
int UART4Data_Process(uint8_t *UART_RX_BUF,uint16_t UART_STA)
{
		char i = 0;
		for(i=0;i<UART_STA;i++)
		{
			switch(UART_RX_BUF[i])
			{
					case 'A':
						Leida_Angle[Leida_count_A] = CharToNum(&UART_RX_BUF[i+1],UART_STA-i-1)/100;
						Leida_count_A==10?Leida_count_A=0:Leida_count_A++;
					break;
					case 'L':
						Leida_Distance[0] = CharToNum(&UART_RX_BUF[i+1],UART_STA-i-1)/1000;
					break;
					case 'R':
						Leida_Distance[1] = CharToNum(&UART_RX_BUF[i+1],UART_STA-i-1)/1000;
					break;	
					case 'B':
						Leida_Distance[2] = CharToNum(&UART_RX_BUF[i+1],UART_STA-i-1)/1000;
					break;						
					default:break;
			}		
		}
    return 0;
}
int UART5Data_Process(uint8_t *UART_RX_BUF,uint16_t UART_STA)
{
		char i = 0;
		for(i=0;i<UART_STA;i++)
		{
			switch(UART_RX_BUF[i])
			{
					default:break;
			}		
		}
    return 0;
}
/**************************************************************************
函数功能：同时接收多类数据时的处理函数
入口参数：数据数组及长度
返回  值：0
**************************************************************************/
int DataS_Process(uint8_t *UART_RX_BUF,uint16_t UART_STA)
{
		u8 i = 0,j = 0,k = 0;		//数组的位数、数据的个数 
		u8 Data_STA[10];		//记录第j个数据最后一位的位置
		static u8 l=0;
		for(i=0;i<UART_STA;i++)
		{
			switch(UART_RX_BUF[i])
			{
					case '~':	
						/*记录i，第j个数据'~'的位置，第0个数据=0*/
						Data_STA[j] = i;
						/*'~'的个数，共j个数*/
						j++;
						break;
					default:break;
			}		
		}
		Data_STA[j] = UART_STA;		
		/*给j个数据进行赋值*/
		for(i=0;i<j;i++)
		{
			for(k=Data_STA[i];k<Data_STA[i+1];k++)
			{
				switch(UART_RX_BUF[k])
				{
					case 'x':
						cross_x = CharToNum(&UART_RX_BUF[k+1],Data_STA[i+1]-k-1);
						break;
					case 'y':
						cross_y = CharToNum(&UART_RX_BUF[k+1],Data_STA[i+1]-k-1);
						break; 
					case 'X':
						fruit[l].X = CharToNum(&UART_RX_BUF[k+1],Data_STA[i+1]-k-1);
						if(fruit[l].object==3) x_pep =  fruit[l].X;
						break;
					case 'Y':
						fruit[l].Y = CharToNum(&UART_RX_BUF[k+1],Data_STA[i+1]-k-1);
						target_y = fruit[l].Y;
						break; 
					case 'F':
						rec_x = CharToNum(&UART_RX_BUF[k+1],Data_STA[i+1]-k-1);
						break; 
					case 'f':
						rec_y = CharToNum(&UART_RX_BUF[k+1],Data_STA[i+1]-k-1);
						break; 
					case 'S':
						eyestate = CharToNum(&UART_RX_BUF[k+1],Data_STA[i+1]-k-1);
						break;
					case 'O':
						object = CharToNum(&UART_RX_BUF[k+1],Data_STA[i+1]-k-1);
						if(object<4)	fruit[l].object =  object;
						break;
					case 'R':		//水果成熟度
						ripe = CharToNum(&UART_RX_BUF[k+1],Data_STA[i+1]-k-1);
						fruit[l].ripe =  ripe;
						break;
					case 'W':
						Wide = CharToNum(&UART_RX_BUF[k+1],Data_STA[i+1]-k-1);
						if(object<4) fruit[l].W = Wide;
						if(fruit[l].object==3) wide_pep =  Wide;
						break;
					case 'H':
						High = CharToNum(&UART_RX_BUF[k+1],Data_STA[i+1]-k-1);
						if(object<4) fruit[l].H = High;
						break;					
					default:
						break;					
				}
			}
		}
		l++;
		if(l>=Fruit_num) 
		{
			flag_over=0,l=0;
			Miny = fruit[0].Y;
			Maxx = fruit[0].X;
			Minx = fruit[0].X;
			Maxw = fruit[0].W;
			ctf = -1;//最左的水果
			for(i=1;i<Fruit_num;i++)
			{
				if(Miny>=fruit[i].Y)
					Miny = fruit[i].Y;
			}
			Dcenter_flag1 = 0;
			Dcenter_flag2 = 0;
			for(i=0;i<Fruit_num;i++)
			{
				//判断XS
				if(fruit[i].object==1&&fruit[i].X>Sx1&&fruit[i].X<Sx2&&fruit[i].W>7)Dcenter_flag1 = 1;
				if(fruit[i].object==1&&fruit[i].X>Sx2&&fruit[i].X<Sx3&&fruit[i].W>7)Dcenter_flag2 = 1;
				//排除太远的水果
				if(fruit[i].W < wlimit)fruit[i].ripe = 0; 
				fruit[i].ratio = fruit[i].W/fruit[i].H;
				//if(Maxw <= (fruit[i].W+1))//最前
				if(!W_flag)
				{
					if((mode_D == 0 && count_D >= 2) || mode_D == 2)//right
					{
						//u5_printf("right!\r\n");
						if(fruit[i].object==1 && Minx >= (fruit[i].X) && fruit[i].ripe && fruit[i].ratio>0.70 && fruit[i].Y>ylimit)//最左
							ctf = i, Minx = fruit[i].X, Maxw = fruit[i].W, fruit_rem = fruit[i];
					}
					else//left
					{
						//u5_printf("left!\r\n");
						if(fruit[i].object==1 && Maxx <= (fruit[i].X) && fruit[i].ripe && fruit[i].ratio>0.70 && fruit[i].Y>ylimit)//最左
							ctf = i, Maxx = fruit[i].X, Maxw = fruit[i].W, fruit_rem = fruit[i];
					}
				}
				else
				{
					//u5_printf("WWWWWWWWWW!\r\n");
					if(fruit[i].object==1 && Maxw <= (fruit[i].W) && fruit[i].ripe && fruit[i].ratio>0.70 && fruit[i].Y>ylimit)//最前
						ctf = i, Maxw = fruit[i].W, fruit_rem = fruit[i];
				}
				
			}
			Minx = 0;
			Maxx = 0;
			Maxw = 0;
			//u5_printf("%.2f\r\n",Miny);
		}
		else flag_over =1;
    return 0;
}
/**************************************************************************
函数功能：将字符形的数字转为float类型
入口参数：特定字母后的字符数字及其长度
返回  值：转换后的数字
**************************************************************************/
float CharToNum(uint8_t *cData,uint8_t len)
{
    uint8_t i=0,dot_count = 0;
    int Num_Return = 0,Num_cnt = 1,Num_Receive;
    for(i=1;i<len+1;i++)
    {
			Num_Receive = *cData-'0';
			switch(dot_count)
			{
					case 0:
						switch(*cData)
						{
								case '.':
									dot_count++;
									break;
								case '-':
									Num_cnt *= -1;
									break;
								default:
									if(Num_Receive>9 || Num_Receive<0) return 0;
									Num_Return = Num_Return*10+Num_Receive;
									break;
						}
						break;
					case 1:
						if(*cData=='.')			//接收到多个‘.’
								return 0;
						else
						{
							if(Num_Receive>9 || Num_Receive<0) return 0;
									Num_Return = Num_Return*10+Num_Receive;
							Num_cnt*=10;
						}							
						break;
					default:
						return 0;
			}
			cData++;
    }
    return Num_Return/1.0/Num_cnt;
}
